home *** CD-ROM | disk | FTP | other *** search
/ Reverse Code Engineering RCE CD +sandman 2000 / ReverseCodeEngineeringRceCdsandman2000.iso / RCE / Ebooks / Thinking in C++ V2 / C24 / Selfrtti.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-25  |  2.5 KB  |  107 lines
  1. //: C24:Selfrtti.cpp
  2. // From Thinking in C++, 2nd Edition
  3. // Available at http://www.BruceEckel.com
  4. // (c) Bruce Eckel 1999
  5. // Copyright notice in Copyright.txt
  6. // Your own RTTI system
  7. #include "../purge.h"
  8. #include <iostream>
  9. #include <vector>
  10. using namespace std;
  11.  
  12. class Security {
  13. protected:
  14.   static const int baseID = 1000;
  15. public:
  16.   virtual int dynamic_type(int id) {
  17.     if(id == baseID) return 1;
  18.     return 0;
  19.   }
  20. };
  21.  
  22. class Stock : public Security {
  23. protected:
  24.   static const int typeID = baseID + 1;
  25. public:
  26.   int dynamic_type(int id) {
  27.     if(id == typeID) return 1;
  28.     return Security::dynamic_type(id);
  29.   }
  30.   static Stock* dynacast(Security* s) {
  31.     if(s->dynamic_type(typeID))
  32.       return (Stock*)s;
  33.     return 0;
  34.   }
  35. };
  36.  
  37. class Bond : public Security {
  38. protected:
  39.   static const int typeID = baseID + 2 ;
  40. public:
  41.   int dynamic_type(int id) {
  42.     if(id == typeID) return 1;
  43.     return Security::dynamic_type(id);
  44.   }
  45.   static Bond* dynacast(Security* s) {
  46.     if(s->dynamic_type(typeID))
  47.       return (Bond*)s;
  48.     return 0;
  49.   }
  50. };
  51.  
  52. class Commodity : public Security {
  53. protected:
  54.   static const int typeID = baseID + 3;
  55. public:
  56.   int dynamic_type(int id) {
  57.     if(id == typeID) return 1;
  58.     return Security::dynamic_type(id);
  59.   }
  60.   static Commodity* dynacast(Security* s) {
  61.     if(s->dynamic_type(typeID))
  62.       return (Commodity*)s;
  63.     return 0;
  64.   }
  65.   void special() {
  66.     cout << "special Commodity function\n";
  67.   }
  68. };
  69.  
  70. class Metal : public Commodity {
  71. protected:
  72.   static const int typeID = baseID + 4;
  73. public:
  74.   int dynamic_type(int id) {
  75.     if(id == typeID) return 1;
  76.     return Commodity::dynamic_type(id);
  77.   }
  78.   static Metal* dynacast(Security* s) {
  79.     if(s->dynamic_type(typeID))
  80.       return (Metal*)s;
  81.     return 0;
  82.   }
  83. };
  84.  
  85. int main() {
  86.   vector<Security*> portfolio;
  87.   portfolio.push_back(new Metal);
  88.   portfolio.push_back(new Commodity);
  89.   portfolio.push_back(new Bond);
  90.   portfolio.push_back(new Stock);
  91.   vector<Security*>::iterator it = 
  92.     portfolio.begin();
  93.   while(it != portfolio.end()) {
  94.     Commodity* cm = Commodity::dynacast(*it);
  95.     if(cm) cm->special();
  96.     else cout << "not a Commodity" << endl;
  97.     it++;
  98.   }
  99.   cout << "cast from intermediate pointer:\n";
  100.   Security* sp = new Metal;
  101.   Commodity* cp = Commodity::dynacast(sp);
  102.   if(cp) cout << "it's a Commodity\n";
  103.   Metal* mp = Metal::dynacast(sp);
  104.   if(mp) cout << "it's a Metal too!\n";
  105.   purge(portfolio);
  106. } ///:~
  107.